The Challenge

Pong was the first widely successful arcade game. It was released in 1972, and started the first arcade boom. The game may seem simple today, but it was designed directly in hardware. Essentially, Pong was a specialized computer designed to bounce a ball between two paddles and keep score.

You don’t have to make this from computer parts, of course! With a modern engine, this should be a fairly simple start.

• Create an arena with two walls and a divider.
• Add a paddle on either end of the play field. Use player inputs to move the paddles up and down.
• Add a ball that moves around the playfield and bounces off of the paddles and walls.
• Detect when the ball leaves the playfield. Assign a point to the player who scored.
• Track and display the score for each player.

• Write an AI script that can follow the ball so you can play with only one player.
  Hint: Following the ball with a paddle is easy, but it makes the opponent impossible to beat. You might want to make the AI less than perfect somehow.
• Add a menu and allow the player to reset the game.
• Add some basic sounds. Play a sound every time the ball collides with something, and every time a player scores.

Flappy bird was a mobile game from 2013. It was a sleeper hit, gaining sudden and massive popularity in 2014, likely due to attention from a popular YouTuber at that time. The game was removed from the App store after it’s sudden popularity due to negative media attention.

The game is extremely simple, and was designed to mimic the feeling of bouncing a ping pong ball on a paddle for as long as possible.
Flappy Bird is a popular first game for new developers, and is featured in many “first game” tutorials.

• Create a game world with a floor.
• Add an object that represents the main character. Apply a constant force to the character so it falls to the floor.
• Add obstacles on the left of the game area. The obstacles should slide across the screen toward the right. The obstacles will appear in pairs, with a vertical gap between them.

  You could create a really long level and hope that the player never gets to the end of it, but it would make more sense if you used code to create obstacles when you need them.

  The game obstacles (pipes) will move off of the screen and never be used again. You might want to delete them once they are no longer useful. Or, better yet, re-use them by moving them to the left side of the screen once they move off of the right side!

• Detect when the character collides with the floor or obstacles, and reset the game when a collision occurs.
• Accumulate one point for each obstacle that the player passes. Display the score.

• Add some sounds that will play each time the player gains a point, and when the player loses.
• Add a basic game-over screen to display the player’s score.
• Track the high-score between play sessions and display the high score alongside the current score.
• Add some background art! Try layering the background and scrolling at a different rate to the foreground obstacles. This is called Parallax scrolling.

Atari’s first successful game (Pong) was massively successful, but many companies made clones of the game, which eroded Atari’s profits. Their response was to make new and innovative games in order to stay ahead of the competition. Breakout was a direct descendent of Pong, but was designed for one player instead of two. It came out in 1976.

Fun fact: Steve Jobs and Steve Wozniak (yes, the Apple guys) worked together to design the Breakout hardware. Like Pong, the game was made from transistors. Again, the game will be much easier to make if you use a modern game engine instead of starting from a pile of wires.

• Create a game space with walls and a ceiling.
• Add a paddle that can be moved left and right via player inputs.
• Add a ball that will bounce off of the paddle, walls, and ceiling.
• Add square game objects (bricks) into the top of the game space.
  (The original game had eight rows of 16 bricks each, though you can change the number of bricks depending on the size of the game space)
• Enable the ball to bounce off of the bricks. When the ball bounces, the brick should disappear.
  • Breaking a brick should add to the player’s score.
  • The ball’s speed should increase as bricks are broken.
• The score should be displayed, as well as a life counter. The player starts with three lives. If the player misses the ball, a life should be subtracted. When all lives are used, the game ends.

• Save the high score between play sessions and display it alongside the player score.
• Add different colors to the bricks in the rows. (The original game was black-and-white, but had a colored film on the screen, simulating colored rows of bricks)
• The paddle should get narrower once the ball reaches the ceiling.

Jetpack Joyride is a side-scrolling endless mobile game from 2011. It only requires a single input button to control the player. The game is fairly complex overall, though the basic premise is very simple. The game came from the same studio that made Fruit Ninja.

The game features a character with a machine-gun jetpack. When holding the input, the player will rise (and destroy everything below!) When the input is released, the character will fall. The character can run on the ground if they reach the bottom of the screen.

This game featured many power-ups and special game modes. The difficulty rating is for the main game mechanic with simple obstacles. If you want to add more to the game, it will be more difficult and take longer to complete.

• Create a game world with a floor. The world will scroll from right to left endlessly.
• Add a player character that falls when no input is held, but rises when the input is held.
• Add obstacles that move from right to left. Feel free to make more than one type of obstacle.
  • Obstacles can be placed in the world using a script so the level can be truly endless.
  • Obstacles should either be deleted or recycled when they leave the screen.
• The score increases with distance. The goal is to beat your previous score, so the high score should be displayed alongside the current score.

• Save the high score between play sessions.
• The jetpack is a machine gun! Add bullet objects that spew from your character when the input is held.
  • Particle effects are a fun way to add game juice. Mess around with some here, making explosions or sparks when things get destroyed!

The launch of Space Invaders in 1978 marked the beginning of the Golden Age of the Arcade. Space Invaders was one of the first games to use a microcomputer. However, off-the-shelf technology was not available, so designer Tomohiro Nishikado had to design the computer hardware himself and write his own development tools before he could program the game. The hardware still struggled to render all of the sprites, so the game (and music) would speed up as aliens were destroyed. Modern systems won’t lag for a game this simple, so you might have to add that feature deliberately!

• Create a player ship that moves side to side.
• Create a few different types of alien invaders.
  • Enemies will move together in a grid. They cross the screen horizontally before dropping vertically and reversing their direction.
• Add the ability for the player ship to fire rockets that travel up the screen.
• Add bombs/bullets that the enemies drop. The player’s rockets can destroy enemy bullets.
• Make sure that the player’s bullets will destroy invaders, and the invader bullets will destroy the player.
• Add a mothership that will cross the screen periodically. Destroying it will result in bonus points.
• Add a UI that tracks the player score and lives left. The player starts with three lives.

• The original game had bunkers that alien bombs and player rockets would slowly destroy.
  Some console ports had bunkers that would be destroyed after a certain number of hits.
  Others omitted bunkers entirely, or made different bunkers for different levels.
  Feel free to add any type of bunker to the game.
• Have fun with particle effects! You aren’t restricted to the original hardware, so feel free to add as much game juice (particles, sounds, screen shake) as possible.

“Frogger has the ominous distinction of being the arcade game with the most ways to die” (Softline, 1982)
Frogger was released in Japan in 1981. The designer, Akira Hashimoto, came up with the idea for the game after he saw a frog trying to cross the road while Hashimoto was stopped at a red light. Instead of distinguishing itself as a technical masterpiece, the game stood out for its “nonviolent” gameplay and unique premise.

• Make and animate a frog. The frog can move up, down, left, or right. Instead of moving smoothly, the frog should hop each time a button is pressed. Each button press will move the frog one tile.
• Make the play area. The area is divided into lanes (rows). There is a safe lane, five lanes of road, another safe lane, and five lanes of water. Finally, there are five lillypads on the top of the screen.
• Make and animate the game obstacles. All obstacles and platforms will cross the screen horizontally. Obstacles will alternate direction for each lane.
  • The road has cars. Each lane has a unique pattern of cars, and speeds vary between lanes.
  • The river has alternating lanes of logs and turtles. Some turtles can dive underwater periodically. Some logs are actually crocodiles, which can eat the player if the player lands in their open mouth.
• The player should die if:
  1. they leave the screen
  2. they are hit by a car
  3. they fall in the water (frogs can drown, apparently)
  4. they are eaten by a wild animal
• If the player reaches a lillypad on the top of the screen, the lillypad will be “full.” When all five lillypads are full, the level is complete.
• Add a UI with a life counter and a score counter.
• Create an animation or use a particle effect to make the frog’s death extra juicy!

• Make multiple levels. Higher difficulty levels feature more (faster) cars, and less platforms. Also, more logs crocodiles, and the center safe zone now features a snake (that can eat the player)

River Raid was released for the Atari 2600 in 1982. The game featured a jet airplane flying up a river, destroying boats, helicopters, jets, and bridges as it went. River Raid used procedural generation to make its levels. The game used a fixed seed, meaning that every level was the same for all players. The game was designed and programmed by Carol Shaw, the first female game designer at Atari, and one of the first worldwide.

• Create and animate a jet fighter. The screen will scroll vertically, and the jet can move side to side. The player can accelerate or brake, which will change the vertical scrolling speed.
• Add a river bank on both sides of the level. The river can vary in size, or even split into two streams. Hitting the river bank will kill the player.
• Divide the game into levels. Between levels, the river will narrow, and there will be a bridge crossing it. Bridges act as checkpoints. The player must shoot the bridge, colliding with it will kill the player.
• Add some enemies! Boats and helicopters will move back and forth across the river. Jets will cross the entire screen. Colliding with an enemy will kill the player.
• Add fuel depots. Flying over these will replenish the player’s fuel reserves. The player can shoot and destroy fuel depots, but colliding with them doesn’t kill the player.
• Add a UI with a life counter, score, and fuel gauge. The fuel gauge will drain slowly, and the player will die if it reaches “empty”
• Give the player the ability to shoot things! Shooting things increases the player score.

• Not sure how to make the game infinitely long? The easy way would be to create multiple hand-crafted levels that start and end with a bridge. The fun way would be to generate the levels dynamically on the fly.
• The Atari 2600 could only display limited sprites. Modern computers are capable of creating massive particle effect explosions. You know what to do 😉

Asteroids was released by Atari in 1979. The game came out one year after Space Invaders, and helped set the pace for the Golden Era of the Arcade. Asteroids is famous for its use of Vector Graphics in lieu of sprites.

There were two competing display technologies in the arcade: Vector and Raster graphics. CRT displays used an electron beam to illuminate the phosphor layer on a display. Raster graphics games (from Latin Rastrum - “rake”) would sweep the beam across the screen line-by-line. Vector graphics took direct control of the beam and drew shapes onto the screen.

Displays today use physical pixels (raster), but graphics cards still use vectors to think, especially when working with 3D geometry. You’ll be working with vectors eventually, even if you opt to use sprites for this game.

• Create a player ship. The ship should be able to rotate and thrust. Thrust will accelerate the ship “forward” in the direction that it is facing.
• Add bullets. The player ship will fire in the direction that it is facing. Bullets will disappear after a short while.
• Create three sizes of asteroids.
  • Asteroids will break into smaller asteroids when shot (The smallest will disappear when shot).
  • Asteroids will drift around until they are shot or they collide with the player. If the player collides with an asteroid, they will lose a life.
• Enable screen wrapping. (Objects leaving the top of the screen should enter the bottom, for example)
• Add menus and UI.
• Add sound effects and particle effects.

• Add a flying saucer that enters the screen and shoots at the player from time to time. The saucer should generally aim towards the player, but shouldn’t have too good of aim!
• Add a “hyperspace warp” that moves the player to a random part of the screen. The warp is a last-ditch attempt to dodge an asteroid, but it could place you in a worse predicament!
• Make it your own - This is a great game to add some custom power-ups to.

Spacewar is one of the earliest known video games. It appeared on the PDP-1 minicomputer at MIT in 1962. Spacewar featured two space ships orbiting a star. Players had to maneuver around the star and shoot their opponent before being shot. The game inspired Atari to make “Computer Space” - the first commercial arcade game.

The game was initially controlled via switches on the computer, but a student at the university designed and built a dedicated control box to prevent excited players from breaking the expensive research computer. The game was quickly banned from the computer lab during working hours due to its addictive nature (and the tendency of students to not get any work done while the game was being played!)

• Create two different ships. One player will control each ship. Ships can rotate and thrust. Thrusting will accelerate the ship “forward” in the direction that it is facing.
• Add the ability for ships to fire torpedoes. The player ship will fire in the direction that it is facing. Torpedoes will disappear after a short while.
• Enable collisions. If two players collide, both lose. If a torpedo hits a player, the other player wins. If two torpedoes collide, both are destroyed.
• Enable screen wrapping. (Objects leaving the top of the screen should enter the bottom, for example)
• Add a star at the center of the screen. Apply gravity (everything will slowly fall towards the star)
• Add sound effects and particles!

• The original Spacewar! was multiplayer only, but feel free to add an AI opponent to face off against!
• Alternatively, this might be a good time to try to make an online multiplayer game. (if that’s a skill that you intend to learn)

Indy 500 was a launch title for the Atari 2600 home entertainment system in 1977. The game featured a top-down view of a race track with two cars. This is the third Indy game that Atari made, though the first two were arcade cabinets. Indy 800 was an eight player cabinet that took up 16 square feet of floor space!

Indy 500 only allowed for two players, so Atari added extra game modes to make up for it. They marketed Indy 500 as “14 games in one” with each individual track counting as a different “game mode.” In reality, there were three game modes: Racing, tag, and “crash and score” - where players tried to be the first to hit a white square with their car.

• Make a race car from a top-down perspective. Cars can only turn when moving forwards or backwards. The car also should accelerate and decelerate smoothly.
• Add controls for up to two players. Player 1 should be able to race against the clock or against another player.
• Create one or more race tracks (from a top-down perspective). The track should be a complete circuit with a finish line. The original game fit the entire race track onscreen, though you can add a dynamic camera if you prefer to have larger tracks.
• Enable collisions with the track boundary and between cars.
• Add a lap/score counter.
• Add menus to select a race track, number of players, etc.

• Add one or more additional game mode.
  • Standard racing: Players race against the clock to complete as many laps as they can, or compete to finish 25 laps (requires two players).
  • Crash and Score: (Two player) Drive into an obstacle which is randomly placed on the track. The square moves each time it is hit.
  • (Two player) This is essentially tag, whoever has the blinking car gains points by avoiding the other player’s car who gains points by “tagging” the blinking car, after which the roles of the players are reversed.
• Try making a simple AI so you can play 2 player mode without a human opponent. You can use waypoints to make a “patrol route,” or try something more complex.
• Why limit yourself to 2 dimensions? Add depth so you can make a figure-8 track that crosses itself with a bridge. You’ll have to think about how to draw all of the layers as the cars move along the track.

Pac-Man changed the arcade industry when it released in 1980. At the time, most developers were focused on the space shooter genre that Space Invaders started. Designer Toru Iwatani didn’t want arcades to only attract boys and men, so he made a game that was colorful and fun enough to appeal to women and children as well.

Pac-Man featured the most complex AI to be seen in the arcade so far. The ghosts followed a set of extremely simple rules, but those rules combined to make the ghosts seem intelligent and strategic.

• Create the Pac-Man maze. Place a score and high score counter above the level, and a life counter below. The maze operates on a grid. There is a tunnel that allows Pac-Man and the ghosts to wrap across the screen, appearing on the other side.
  • Fill the maze with dots and four large dots (Power Pellets). Each cell in the grid will contain a dot or power pellet.
• Create Pac-Man himself. He should be able to move in four directions through the maze. When Pac-Man collides with a dot, he will eat it, increasing the score.
• Add four ghosts. They will chase Pac-Man through the level. The ghosts start in a “pen” and are released after enough dots are eaten. Each ghost will cycle between “chase mode” and “scatter mode.” During chase mode, the ghosts will move toward specific cells to give the illusion of teamwork and intelligence.
  • Red ghost “Blinky” will target Pac-Man directly.
  • Pink ghost “Pinky” will try to get 4 tiles in front of Pac-Man.
  • Blue ghost “Inky” will target a special position. Draw a line from Blinky’s position to the cell two tiles in front of Pac-Man, then double the length of the line. That is Inky’s target position.
  • Orange ghost “Clyde” will target Pac-Man directly, but will scatter whenever he gets within an 8 tile radius of Pac-Man.
  • Each ghost has an assigned corner that it will scatter to during scatter mode.
  • For more details on the Pac-Man AI, check out this detailed breakdown. If you are using a modern game engine, then you will probably solve some problems (such as pathfinding) differently and will therefore have to improvise a little.
• Add the “power pellet” mode. When Pac-man eats the pellet, the ghosts will turn blue (scared), and will scatter. Pac-Man can eat the ghosts. After a timer elapses, the ghosts will flash white, then return to normal. Eaten ghosts will award points, turn into eyes, and then return to the pen before coming back as regular ghosts.
• Add the win states and lose states. Pac-Man will die when eaten by a ghost, consuming a life. When all dots are consumed, the level will reset.

• Feel free to customize the maze, add more/different AI behaviors, or add more levels.
• Add fruit pickups. Fruit appears after enough dots are eaten, and awards bonus points. (This is a stretch goal because I forgot about it until now…)

Tic-tac-toe (also known as noughts and crosses) is a fairly simple game played on a grid. Because of its low complexity, this game was one of the earliest to be solved by computers. In 1950 (two decades before Pong), an “arcade game” named Bertie the Brain was shown off at the Canadian National Exhibition. Bertie would play tic-tac-toe against human opponents using a bank of colored light bulbs. Two years later, the EDSAC research computer was programmed to play tic-tac-toe on a CRT monitor. Both computers were able to play optimally against a human player.

• Create a 3 by 3 grid for the game board. Each cell in the grid should be able to hold an X, an O, or be empty.
• Make each cell selectable. Two players should alternate turns. One player is X, and the other is O. When an empty cell is clicked, an X or O should be placed there.
• Detect a win condition. If three X’s or three O’s are in a row (vertically, horizontally, or diagonally), then the player who placed them wins. If the board is filled before someone gets three in a row, then the game is a tie.
• Create an AI opponent. The AI needs to be able to read the board state, evaluate the best move to make, and then place an X or O in the appropriate cell. Try to make an AI yourself before looking up solutions online. Your ideas probably won’t be as good as the collective internet, but you’ll learn more if you think if through for yourself first.

  AI design isn’t just about making the best algorithm. Good AI systems will show off their intelligence to the player in order to feel more human. Try adding an artificial delay on the AI’s turn to make it feel like it’s thinking for a second or two.

  You could take it a step farther and add a chat window for the computer player to tell you what it’s thinking. (This kind of communication is called “barks.”) If you can find a way to show your work off to the player, they will see more of the complexity in your AI (even if it is faked), and think that it is “smarter” as a result.

• Add menus and a UI. Consider adding a match counter for multiple rounds.

• Once you have your AI working, look up optimal strategy tables to see if your AI is playing as well as it can. Play code golf - try to refactor the AI to be as small, simple, or fast as possible.
• You can also try implementing an online AI at this point (like the minimax algorithm). You can even set up a 0 player game to let your first AI play against the internet’s AI. Experiment with game trees,

Conway’s Game of Life is not technically a video game; it is a cellular automata. Referred to as a “zero player game,” it requires no input beyond the initial state. British mathematician John Conway devised the rules for the simulation in 1970, doing the majority of his experiments with pen and paper.

The Game of Life has become a staple of recreational computing and recreational mathematics. The game helped launch the field of cellular automata. The Game of Life is impressive because the rules are so simple, and yet the outcome can be incredibly complex. The Game of Life is Turing-complete, which means that you could theoretically use it as a language to make your next game in! (though that would not be advised…)

• Create the “Universe” - a square grid with cells that can be “alive” or “dead,” represented by two different colors.
  The universe is infinite in theory, but you might want to pick a grid size that can fit within a computer’s memory 🙂
• The simulation will occur in steps, or “generations.” Make the appropriate data structures to track both the current and future generation.
• Allow the player to toggle any of the cells between alive and dead.
• Allow the player to start, stop, and reset the simulation. You might also want to make the simulation speed variable.
• During the simulation, each cell will follow a simple set of rules:
  • Any live cell with fewer than two live neighbors dies.
  • Any live cell with two or three neighbors lives on in the next generation.
  • Any live cell with more than three live neighbors dies.
  • Any dead cell with exactly three live neighbors becomes alive in the next generation.

• Feel free to mess with the rules to see what happens. Alternatively, you can try to implement other cellular automata if you’re up for a bigger challenge.
• Get lost in the game of life wiki for hours, and implement your own oscillators, spaceships, gliders, guns, and puffers. Watch the little critters crawl around your game all on their own.

Super Mario Bros is one of the most iconic and well-known games of all time. Nintendo released the game on the NES in 1985. The game and the console helped revitalize the US video game market after the crash of 1983. There are now more than 20 games in the Super Mario series.

Fun fact: Super Mario Bros has been optimized by speedrunners. If you spend multiple years practicing, then you might be able to beat the game in only 4 minutes and 54 seconds! Re-creating the game is probably less work…

• Create a 2D character controller. Mario should be able to walk, run, and jump.
• Create a single level. You can make world 1-1, or design your own level. The level should be made up of textured tiles. There will also be some special elements:
  • Add “question mark” boxes. These will contain coins or power ups.
  • Add warp pipes. Mario should be able to enter these by pressing the “down” button. He will exit a pipe somewhere else on the map.
  • At the end of the level should be a castle and a flagpole. Touching the flagpole will end the level.
• Add enemies to the level. Goombas will walk in a straight line and turn around when they hit something. Jumping on a Goomba will squash it. Koopas will retreat into their shell when stomped on. The shell will move when hit again.
• Add power ups. A mushroom will cause Mario to increase in size. Feel free to add stars or fire flowers as well.
• Make your own sprites, sound effects, and music. Pay special attention to the artwork for repeating tiles, pattern should look good when repeated.
• Add a life counter and level timer. Mario will die if the timer reaches zero before he finds the level exit.

• Make all of the background art for the level.
• Make an animated sequence at the end of the level. Touching the flagpole should cause the flag to drop before Mario walks into the castle, exiting the level.
• Make some more levels. Re-make an entire world, or design your own levels.

According to its designer, Pitfall took 10 minutes to design, but 1000 hours to program. The game released in 1982, and was the #1 best selling Atari 2600 game for more than a year. The Atari 2600 could only draw two player sprites and three one-pixel bullets (it was essentially designed to play Pong), so Pitfall had to move or modify the sprites on every scanline in order to build the complex world.

The entire world was built from an 8 bit polynomial counter, resulting in 255 pseudorandom playable screens. The entire game took only 4 kilobytes of ROM! The goal of the game is to collect 32 treasures in the world within 20 minutes.

• Create a 2D character controller. The player should be able to walk left or right, jump, hold onto swinging vines, and climb up and down ladders.
• Create a world made up of pseudo-randomly generated game screens. Each screen should contain an upper level and an underground tunnel. The upper level should have one of the following:
  • A ladder connecting the upper and lower levels, or a ladder with a hole on each side that the player can fall through.
  • A tar pit (black). The pit can be crossed by swinging on a vine, or will expand and contract, allowing the player to run across.
  • A lake (blue). The lake can by crossed by jumping across the heads of 3 alligators that will open and close their mouths. Alternatively, the lake can expand and contract, or be crossed with a vine.
  • There are also logs that will roll across the screen on some levels, causing the player to trip.
  • There can be a static hazard to jump over (a fire or a snake), or a treasure to collect.
• The tunnel will contain a scorpion that walks towards the player. Alternatively, it can contain a ladder and/or a brick wall. The brick wall blocks the path, forcing the player to go above-ground.
• Exiting a screen above-ground will move to the next (or previous screen). Exiting a screen in the tunnel will move forward or backward 3 screens.
• Make sure to record your best Tarzan yell for the player when he swings on a vine. (You should probably add other sound effects, too.)
• Add some background art as well. Moving the trees around for each level will give the impression that you are wandering through a random forest instead of just visiting the same screen repeatedly.
• Add a score counter, life counter, and timer.

• The original game only took 4 KB of disk space. You won’t get close, but do try to optimize you game a bit. See if you can figure out how to derive an entire map from an 8-bit number. (If you can’t figure it out, feel free to look it up, it’s a really cool piece of code!)
• Feel free to make a “modern remake” of Pitfall with fancier graphics and sprite animations.

VVVVVV is a retro puzzle-platformer. It came out in 2010, but it could have been at home in early 8-bit games. Instead of jumping, the player controls gravity, allowing the protagonist to fall upwards or downwards. The game is a great example of designing within constraints. Instead of focusing on “modern” graphics and sound, the game limits itself to simple sprites and chip-tune music.

• Create a 2D character controller. The player should be able to walk left or right. They cannot jump, instead gravity will reverse directions. Gravity will only change if the player is standing on a surface.
• Create a puzzle level. Each level will be made up of multiple rooms.
  • Rooms can contain spikes, moving platforms, moving enemies, or dissolving platforms (that disappear a second after they player stands on them)
  • The player can exit the room in any direction, and will walk or fall into an adjacent room when they do so.
  • Each room will contain one or more checkpoints. When a player touches a checkpoint, that checkpoint will light up. Players will return to the illuminated checkpoint when they die (even if it is in another room).
• Make some music and sound effects! (If you want to learn to make your own music, then take this opportunity to learn about chip-tunes, and compose something fun!)

• VVVVVV is a simple concept, but contains a lot of polish, refinement, and charm. Add a unique theme to each room in your level.
  
  Try to make each room (or set of rooms) into a complete and unique puzzle. Share your game with friends or on the community discord, and ask for level design feedback. Feel free to iterate a few times until the difficulty feels just right.

Worms is a turn-based artillery game from 1995. In the game, two or more teams of worms take turns shooting each other with various weapons, including rockets, grenades, dynamite (and, of course, the Holy Hand Grenade.) The game featured fully destructible 2D terrain, with each weapon leaving a large circular crater in the landscape. By the end of most matches, the level is an unrecognizable mess of holes and caverns.

• Create a 2D game world with fully destructible terrain. The world should be an organic shape (as opposed to a tile set), and you should be able to cut holes into it, revealing the background.
• Create the worm characters. They are 2D characters that can walk, jump, and shoot.
• You should make weapon selection menu and give the worms some weapons. At minimum, you should give them a bazooka and a throwable grenade. Weapons will create a circular explosion when detonated. Worms caught in the explosion radius will be damaged. Terrain in the explosion radius will also be destroyed, leaving a hole.
• Create a game menu, turn system, and UI. Players will take turns controlling a worm on their team. The turn ends when the worm fires a weapon. Worms will take damage from weapons, and will die when their health reaches 0 (or if they fall off of the map). Dead worms will explode, damaging any nearby worms.

• Create the Ninja rope (a grappling hook that allows worms to swing side to side and extend/retract the rope to move)
• Give the worms a jetpack to allow them to move from place to place.

Dig Dug is a “strategic mining game” released by Namco in 1982. This arcade game featured the very cute premise that you can kill animals by inserting a bicycle pump under their skin, then inflating them until they pop like a balloon!

• Create a tile-based level. The world is made of dirt tiles (with different colors for different layers).
• Create the protagonist. You can walk and dig up, down, left, or right. Digging into a tile will destroy it, turning it into an air tile.
• Create enemies. They will spawn in open spaces (3-5 connected tiles) and will walk back and forth in their spaces.
  • Every now and then, an enemy will “burrow” towards the player, turning into a pair of eyes as they move through the dirt. Enemies will stop burrowing when they reach an air tile.
• Create rocks. When the tile below a rock is dug out, the rock will shake for a second, then will fall. It will kill anyone that it collides with (including the player).
• Give the player an “air pump” weapon. They will shoot a hose in the direction that they are facing. If it connects with an enemy, the enemy will swell up and explode.
• Add a score counter, a life counter, and a level counter. Enemies will get faster with each level.

• Create a starting animation for the game. Dig Dug will start on the surface and burrow down into the center of the level before the game starts.

Super Monkey Ball is a physics-based platformer from 2001. Monkey Ball started as an arcade unit, but the game was brought to the GameCube (and had the “Super” added to the name). The game was a unique combination of first-person play and physics-based control.

Instead of controlling the character directly, the player would change the slope of the level, causing the ball to roll around. Super Monkey Ball came with multiple race modes and mini-games. Some game modes allowed the player to control the ball directly instead of tilting the level.

• Create a handful of game levels, each with a starting area and an ending area. You can make the level flat, or add some 3D slopes and hills.
• Create a sphere representing the player. (You can add a character inside the “ball,” or stick with a simple sphere)
• There are two possible control styles. You can either apply forces to the ball directly, causing it to roll, or change the slope of the map, allowing gravity to roll the ball. You can focus on one control scheme if you prefer.
• Create a banana collectable, and place multiple collectables in each level.
• Add a menu and a UI with a score counter, life counter, and timer.
• Add checks for the different win and fail conditions. The player loses a life if they run out of time or fall off of the level. The player wins when they touch the goal.

• Make a full set of 10 or more levels. Sort the levels by difficulty, creating a sense of progression. Keep the player’s score and life counter from level to level.

Star Fox was an incredibly ambitious rail shooter when it released on the SNES in 1993. Star Fox was the first Nintendo game to feature 3D polygonal graphics, thanks to a Super FX graphics chip that was included in the game cartridge itself. The cartridge contained more more processing power than the game console did. (Imaging buying a game that comes with its own dedicated graphics cards today!)

Star Fox is considered one of the most successful games of all time, and it became a long-running series. The graphics have greatly improved since the first game, so don’t feel like you have to limit yourself to the polygon count of the original.

• Create the world for a 3D rail shooter. The player will travel in a 2D “box” through a 3D world. The movement should follow a predefined path, though the player can control the speed of movement.
  • You can make a space level - where there are only enemies, or you can add terrain and obstacles to avoid.
• Add a player ship. The player can move anywhere on the screen (in 2D space), but the larger movement is controlled by the level. You can add a boost and brake feature to speed up and slow down the player’s movements.
• Add enemies to the game. Enemies can be be static, cross the player’s path, or travel with the player. Enemies will shoot at the player (and the player can shoot back).
  • Feel free to group enemies together in different patterns. You can re-use patterns throughout the level.
• Add a score counter and life counter

• Make a giant boss to fight at the end of the level! The boss should travel with the player until defeated, and can have multiple attack patterns and weak spots.
• Give the player an upgrade! Add a power-up that improves the speed or power of their laser.
• Give the player some bombs. They only get a few per level, but a bomb can clear most or all of the onscreen enemies at once.

In 1996, Crash Bandicoot released for the PlayStation. The developers wanted to make a 3D character platformer game, but didn’t want the player to only see the backside of the character. During the game’s design, the team also realized that a full 3D world would be quite boring when compared to a linear 2D world like Sonic’s. The solution was to remove a dimension or two from each level. Some levels were a side-scrolling platformer, some were liner corridors, and others were time-constrained. The end result was a much faster-paced game than a more open platformer like Super Mario 64.

For this challenge, just focus on the 2.5D platforming segments. If you want, you can expand to other level types from there.

• Create a 2D platformer level with 3D assets. The world should contain platforms, spikes, crates, and moving enemies.
  • There are many possible hazards, but you should at least make something that has to be avoided, something that can be defeated by jumping on it, and something that can be defeated with a spin-attack.
• Create a character. The character should be able to walk, jump, and spin-attack. They will be primarily moving in 2 dimensions, but you can add the ability to move in full 3D space if you want. (This would be necessary if you want to make more level types.)
• Add a score counter and life counter. The player can increase their score by breaking crates in the level.

• Create one or more additional level type:
  • Over-the-shoulder - Crash is running into the screen down a narrow corridor.
  • Boulder Chase - Crash is running into the screen. He is being chased by a boulder (and must therefore run at full speed)
  • Hog wild - Crash is riding a wild hog at full speed (same as the boulder chase, but moving in the opposite direction)
  • 3D level - Combine over-the-shoulder sections with 2.5D platforming sections in the same level.

Doom is widely known as the father of the FPS genre. Id software released Wolfenstein 3D in 1992. Doom was released at the end of 1993, just a year and a half later. The game engine was a refinement of Wolfenstein’s ideas, with more advanced mechanics and a more complex 3D engine. The game uses 2D sprites in a 3D world (sometimes called “2.5D”), but the player was able to move in any direction, and the world contained a lot of elevation and varied geometry.

Doom had many imitators, but the “doom clones” eventually began to diverge, and they were eventually renamed to “FPS games.” Some of Doom’s ideas seem outdated now, but the game still influences many of its successors even today.

• Create a first person controller for the player. The player should be able to look up, down, left, and right. They should also be able to walk forwards and backwards, as well as strafe and jump.
• Create one or more “arena” levels. Arenas can be built from primitive shapes, but they should have some verticality (slopes, stairs, or elevators).
• Add one or more enemy variants. Enemies should wait until the player is nearby, then shoot or attack the player. Feel free to play with more advanced movement/timing mechanics.
• Add two or more weapons. You should make 1. a hitscan weapon that deals instant damage, and 2. a projectile weapon that fires a physical bullet which will travel to the target.
• Add a UI with a health bar and ammo count. The player will receive damage when attacked, and will die when their health reaches zero.
• Add a health pickup that restores player health and an ammo pickup that increases the player’s ammo count.

• In Doom 1993, enemies were billboard sprites (2D images in 3D space), but you can make fully 3D enemies if you want.
• Feel free to play with AI behaviors for the enemies. You can make an “Ai director” that manages when each enemy can move or attack.

In 1992, Nintendo released it’s first kart racing game, Super Mario Kart. The game started out as a generic kart racing game, but the team decided to test out the game with Mario and friends behind the wheel. It was a perfect match, and the theme stuck. The original Super Mario Kart used “Mode-7 Graphics” to simulate 3D. The second game, Mario Kart 64, featured true polygonal terrain with billboard sprites for the players. The Mario Kart series has undergone a gradual refinement; the most recent game features many of the themes, tracks, and items that were introduced in the very first game.

Feel free to re-make your favorite map or item, or add your own flavor to the game!

• Implement a kart for the player to drive. The kart should be able to accelerate, brake, and turn.
• Create one or more tracks. The track should be a complete circuit with a start/finish line. Add hills, jumps or other special features.
• Add AI opponents. They should be able to race around the track alongside the player. Mario Kart heavily features “Rubber-banding,” so you should add that too.

  Rubber-Banding is a controversial topic in video games. Players want to be challenged, but they don’t want to feel like they are being played down to.

  Mario Kart will empower players in the back and disempower players in the front. Some games in the series were more overt than others. Try to find a balance in your version; make the game fun and exciting without being overtly condescending.

• Add item boxes to the track. Add a few different types of items (mushroom, shell, banana, etc.), and allow both the player and the AI racers to use the items.
• Add a UI with lap counter, lap time, and position.

• Add a “hop and drift to boost” mechanic. Add a button that allows the kart to jump. After landing, the kart will be able to drift around corners (the facing direction is no longer in-line with the direction of travel)
• Implement a mini-map that shows the position of the player and other racers.
• Try your hand at networking, and make the game multiplayer!

Minecraft is the single best-selling video game of all time. It came out it 2011, and combined the voxel-based mining of Infiniminer with iconic graphics and a dynamic difficulty curve based around day-night cycles.

Minecraft helped popularize voxel based world generation. Its infinite world is generated dynamically, one chunk at a time.

• Create a first-person player controller. The player should be able to look in any direction, jump, walk, and strafe.
• Create a voxel-based world. Use procedural generation and noise to create hills, trees, and caves.

  Minecraft uses cubes to generate its world. For performance reasons, Minecraft will create one mesh per chunk to send to the GPU. The inside of the world isn’t actually rendered, it’s completely hollow.

  Once you know how to make Minecraft, creating a “smooth” voxel terrain is fairly easy as well. You just have to smooth out the bumps between cubes by moving the corners of the cubes up or down a bit.

• The player should be able to remove blocks from the terrain, and add new blocks.

• Add the option to save your game and load the world from a file. (You might want to re-generate parts of the world, but store player-made changes somewhere)
• There are a lot of potential features to Minecraft, so feel free to add one or more on top of the basic “mining and placing blocks” part. Some potential features to add:
  • An inventory and crafting system.
  • A day/night cycle.
  • Multiplayer support.
  • Water and fluid simulation.
  • Enemies and combat.

Portal was released by Valve as a part of the Orange Box bundle in 2007. Portal’s mind-bending teleportation puzzles and witty humor made it an instant classic.

Portal’s most iconic game mechanic is of course the portals themselves. This game is a good example of computers not understanding “intuitive” mechanics. Portals make sense conceptually, but the game designers had to solve a lot of problems in order to get them to work. In your version, you’ll have to manually teach to computer to understand basic physics and light mechanics.

• Create a 3D first-person controller. The player should be able to walk, run, and jump. The player should have limited “air control” when falling, and they should be able to move at high speeds (though they should have a reasonable terminal velocity)
• Create one or more “test chambers.” You can re-create a level from the game, or make your own.
  • Add buttons, boxes, and moving platforms. You can make more puzzle elements if you want.
• Create a portal gun. The gun will place a portal where the player shoots. (The portal will probably require a custom shader and custom physics rules).
  • There are two portals, orange and blue. Portals will move objects or the player to the other portal while conserving momentum.
  • The player can see through portals (and see other portals through the portal, possibly recursively).
  • Portals can only be created on portal-able surfaces. However, portals can be placed anywhere on the surface. If a portal is too close to the edge of a surface, or another portal, it should be placed in a reasonable location near the crosshairs.

• Refine the portal mechanic. Add custom shaders or particle effects to the portal to make the science-fiction magic seem more believable. Ensure that every corner case works like you would expect.
• Add more mechanics and/or levels.
• Don’t forget to make a cake. Don’t give it to the player. The cake is a lie.